Also add gtk_snapshot_push_repeat() and use that to draw backgrounds.
With that change, CSS background snapshots are created without Cairo
nodes.
gsk_opacity_node_new
gsk_opacity_node_get_child
gsk_color_matrix_node_new
+gsk_repeat_node_new
gsk_clip_node_new
gsk_clip_node_get_child
gsk_rounded_clip_node_new
gtk_snapshot_push_transform
gtk_snapshot_push_opacity
gtk_snapshot_push_color_matrix
+gtk_snapshot_push_repeat
gtk_snapshot_push_clip
gtk_snapshot_push_rounded_clip
gtk_snapshot_pop
* @GSK_TRANSFORM_NODE: A node that renders its child after applying a
* matrix transform
* @GSK_OPACITY_NODE: A node that changes the opacity of its child
+ * @GSK_COLOR_MATRIX_NODE: A node that applies a color matrix to every pixel
+ * @GSK_REPEAT_NODE: A node that repeats the child's contents
* @GSK_CLIP_NODE: A node that clips its child to a rectangular area
* @GSK_ROUNDED_CLIP_NODE: A node that clips its child to a rounded rectangle
* @GSK_SHADOW_NODE: A node that draws a shadow below its child
GSK_TRANSFORM_NODE,
GSK_OPACITY_NODE,
GSK_COLOR_MATRIX_NODE,
+ GSK_REPEAT_NODE,
GSK_CLIP_NODE,
GSK_ROUNDED_CLIP_NODE,
GSK_SHADOW_NODE,
const graphene_matrix_t *color_matrix,
const graphene_vec4_t *color_offset);
+GDK_AVAILABLE_IN_3_90
+GskRenderNode * gsk_repeat_node_new (const graphene_rect_t *bounds,
+ GskRenderNode *child,
+ const graphene_rect_t *child_bounds);
+
GDK_AVAILABLE_IN_3_90
GskRenderNode * gsk_clip_node_new (GskRenderNode *child,
const graphene_rect_t *clip);
return &self->color_offset;
}
+/*** GSK_REPEAT_NODE ***/
+
+typedef struct _GskRepeatNode GskRepeatNode;
+
+struct _GskRepeatNode
+{
+ GskRenderNode render_node;
+
+ GskRenderNode *child;
+ graphene_rect_t child_bounds;
+};
+
+static void
+gsk_repeat_node_finalize (GskRenderNode *node)
+{
+ GskRepeatNode *self = (GskRepeatNode *) node;
+
+ gsk_render_node_unref (self->child);
+}
+
+static void
+gsk_repeat_node_draw (GskRenderNode *node,
+ cairo_t *cr)
+{
+ GskRepeatNode *self = (GskRepeatNode *) node;
+ cairo_pattern_t *pattern;
+ cairo_surface_t *surface;
+ cairo_t *surface_cr;
+
+ surface = cairo_surface_create_similar (cairo_get_target (cr),
+ CAIRO_CONTENT_COLOR_ALPHA,
+ ceilf (self->child_bounds.size.width),
+ ceilf (self->child_bounds.size.height));
+ surface_cr = cairo_create (surface);
+ cairo_translate (surface_cr,
+ - self->child_bounds.origin.x,
+ - self->child_bounds.origin.y);
+ gsk_render_node_draw (self->child, surface_cr);
+ cairo_destroy (surface_cr);
+
+ pattern = cairo_pattern_create_for_surface (surface);
+ cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT);
+ cairo_pattern_set_matrix (pattern,
+ &(cairo_matrix_t) {
+ .xx = 1.0,
+ .yy = 1.0,
+ .x0 = - self->child_bounds.origin.x,
+ .y0 = - self->child_bounds.origin.y
+ });
+
+ cairo_set_source (cr, pattern);
+ cairo_paint (cr);
+
+ cairo_pattern_destroy (pattern);
+ cairo_surface_destroy (surface);
+}
+
+#define GSK_REPEAT_NODE_VARIANT_TYPE "(dddddddduv)"
+
+static GVariant *
+gsk_repeat_node_serialize (GskRenderNode *node)
+{
+ GskRepeatNode *self = (GskRepeatNode *) node;
+
+ return g_variant_new (GSK_REPEAT_NODE_VARIANT_TYPE,
+ (double) node->bounds.origin.x, (double) node->bounds.origin.y,
+ (double) node->bounds.size.width, (double) node->bounds.size.height,
+ (double) self->child_bounds.origin.x, (double) self->child_bounds.origin.y,
+ (double) self->child_bounds.size.width, (double) self->child_bounds.size.height,
+ (guint32) gsk_render_node_get_node_type (self->child),
+ gsk_render_node_serialize_node (self->child));
+}
+
+static GskRenderNode *
+gsk_repeat_node_deserialize (GVariant *variant,
+ GError **error)
+{
+ double x, y, width, height, child_x, child_y, child_width, child_height;
+ guint32 child_type;
+ GVariant *child_variant;
+ GskRenderNode *result, *child;
+
+ if (!check_variant_type (variant, GSK_REPEAT_NODE_VARIANT_TYPE, error))
+ return NULL;
+
+ g_variant_get (variant, GSK_REPEAT_NODE_VARIANT_TYPE,
+ &x, &y, &width, &height,
+ &child_x, &child_y, &child_width, &child_height,
+ &child_type, &child_variant);
+
+ child = gsk_render_node_deserialize_node (child_type, child_variant, error);
+ g_variant_unref (child_variant);
+
+ if (child == NULL)
+ return NULL;
+
+ result = gsk_repeat_node_new (&GRAPHENE_RECT_INIT (x, y, width, height),
+ child,
+ &GRAPHENE_RECT_INIT (child_x, child_y, child_width, child_height));
+
+ gsk_render_node_unref (child);
+
+ return result;
+}
+
+static const GskRenderNodeClass GSK_REPEAT_NODE_CLASS = {
+ GSK_REPEAT_NODE,
+ sizeof (GskRepeatNode),
+ "GskRepeatNode",
+ gsk_repeat_node_finalize,
+ gsk_repeat_node_draw,
+ gsk_repeat_node_serialize,
+ gsk_repeat_node_deserialize
+};
+
+/**
+ * gsk_repeat_node_new:
+ * @bounds: The bounds of the area to be painted
+ * @child: The child to repeat
+ * @child_bounds: (optional): The area of the child to repeat or %NULL to
+ * use the child's bounds
+ *
+ * Creates a #GskRenderNode that will repeat the drawing of @child across
+ * the given @bounds.
+ *
+ * Returns: A new #GskRenderNode
+ *
+ * Since: 3.90
+ */
+GskRenderNode *
+gsk_repeat_node_new (const graphene_rect_t *bounds,
+ GskRenderNode *child,
+ const graphene_rect_t *child_bounds)
+{
+ GskRepeatNode *self;
+
+ g_return_val_if_fail (bounds != NULL, NULL);
+ g_return_val_if_fail (GSK_IS_RENDER_NODE (child), NULL);
+
+ self = (GskRepeatNode *) gsk_render_node_new (&GSK_REPEAT_NODE_CLASS, 0);
+
+ graphene_rect_init_from_rect (&self->render_node.bounds, bounds);
+ self->child = gsk_render_node_ref (child);
+ if (child_bounds)
+ graphene_rect_init_from_rect (&self->child_bounds, child_bounds);
+ else
+ graphene_rect_init_from_rect (&self->child_bounds, &child->bounds);
+
+ return &self->render_node;
+}
+
+GskRenderNode *
+gsk_repeat_node_get_child (GskRenderNode *node)
+{
+ GskRepeatNode *self = (GskRepeatNode *) node;
+
+ g_return_val_if_fail (GSK_IS_RENDER_NODE_TYPE (node, GSK_REPEAT_NODE), NULL);
+
+ return self->child;
+}
+
+const graphene_rect_t *
+gsk_repeat_node_peek_child_bounds (GskRenderNode *node)
+{
+ GskRepeatNode *self = (GskRepeatNode *) node;
+
+ g_return_val_if_fail (GSK_IS_RENDER_NODE_TYPE (node, GSK_REPEAT_NODE), NULL);
+
+ return &self->child_bounds;
+}
+
/*** GSK_CLIP_NODE ***/
typedef struct _GskClipNode GskClipNode;
const graphene_matrix_t * gsk_color_matrix_node_peek_color_matrix (GskRenderNode *node);
const graphene_vec4_t * gsk_color_matrix_node_peek_color_offset (GskRenderNode *node);
+GskRenderNode * gsk_repeat_node_get_child (GskRenderNode *node);
+const graphene_rect_t * gsk_repeat_node_peek_child_bounds (GskRenderNode *node);
+
const graphene_point_t * gsk_linear_gradient_node_peek_start (GskRenderNode *node);
const graphene_point_t * gsk_linear_gradient_node_peek_end (GskRenderNode *node);
const gsize gsk_linear_gradient_node_get_n_color_stops (GskRenderNode *node);
}
else
{
- int surface_width, surface_height;
- cairo_rectangle_t fill_rect;
- cairo_surface_t *surface;
- cairo_t *cr, *cr2;
-
- cr = gtk_snapshot_append_cairo_node (snapshot,
- &GRAPHENE_RECT_INIT (0, 0, width, height),
- "BackgroundLayer<%u>", idx);
+ float repeat_width, repeat_height;
+ float position_x, position_y;
+ graphene_rect_t fill_rect;
/* If ‘background-repeat’ is ‘round’ for one (or both) dimensions,
* there is a second step. The UA must scale the image in that
if (hrepeat == GTK_CSS_REPEAT_STYLE_SPACE)
{
double n = floor (width / image_width);
- surface_width = n ? round (width / n) : 0;
+ repeat_width = n ? round (width / n) : 0;
}
else
- surface_width = round (image_width);
+ repeat_width = round (image_width);
if (vrepeat == GTK_CSS_REPEAT_STYLE_SPACE)
{
double n = floor (height / image_height);
- surface_height = n ? round (height / n) : 0;
+ repeat_height = n ? round (height / n) : 0;
}
else
- surface_height = round (image_height);
-
- surface = cairo_surface_create_similar (cairo_get_target (cr),
- CAIRO_CONTENT_COLOR_ALPHA,
- surface_width, surface_height);
- cr2 = cairo_create (surface);
- cairo_translate (cr2,
- 0.5 * (surface_width - image_width),
- 0.5 * (surface_height - image_height));
- _gtk_css_image_draw (image, cr2, image_width, image_height);
- cairo_destroy (cr2);
-
- cairo_set_source_surface (cr, surface,
- _gtk_css_position_value_get_x (pos, width - image_width),
- _gtk_css_position_value_get_y (pos, height - image_height));
- cairo_pattern_set_extend (cairo_get_source (cr), CAIRO_EXTEND_REPEAT);
- cairo_surface_destroy (surface);
+ repeat_height = round (image_height);
if (hrepeat == GTK_CSS_REPEAT_STYLE_NO_REPEAT)
{
- fill_rect.x = _gtk_css_position_value_get_x (pos, width - image_width);
- fill_rect.width = image_width;
+ fill_rect.origin.x = _gtk_css_position_value_get_x (pos, width - image_width);
+ fill_rect.size.width = image_width;
}
else
{
- fill_rect.x = 0;
- fill_rect.width = width;
+ fill_rect.origin.x = 0;
+ fill_rect.size.width = width;
}
if (vrepeat == GTK_CSS_REPEAT_STYLE_NO_REPEAT)
{
- fill_rect.y = _gtk_css_position_value_get_y (pos, height - image_height);
- fill_rect.height = image_height;
+ fill_rect.origin.y = _gtk_css_position_value_get_y (pos, height - image_height);
+ fill_rect.size.height = image_height;
}
else
{
- fill_rect.y = 0;
- fill_rect.height = height;
+ fill_rect.origin.y = 0;
+ fill_rect.size.height = height;
}
- cairo_rectangle (cr, fill_rect.x, fill_rect.y,
- fill_rect.width, fill_rect.height);
- cairo_fill (cr);
+ position_x = _gtk_css_position_value_get_x (pos, width - image_width);
+ position_y = _gtk_css_position_value_get_y (pos, height - image_height);
+
+ gtk_snapshot_push_repeat (snapshot,
+ &fill_rect,
+ &GRAPHENE_RECT_INIT (
+ position_x, position_y,
+ repeat_width, repeat_height
+ ),
+ "BackgroundLayerRepeat<%u>", idx);
+
+ gtk_snapshot_translate_2d (snapshot,
+ position_x + 0.5 * (repeat_width - image_width),
+ position_y + 0.5 * (repeat_height - image_height));
+ gtk_css_image_snapshot (image, snapshot, image_width, image_height);
- cairo_destroy (cr);
+ gtk_snapshot_pop_and_append (snapshot);
}
gtk_snapshot_translate_2d (snapshot, - origin->bounds.origin.x, - origin->bounds.origin.y);
cairo->height = ceilf (graphene->origin.y + graphene->size.height) - cairo->y;
}
+static GskRenderNode *
+gtk_snapshot_collect_repeat (GskRenderNode **nodes,
+ guint n_nodes,
+ const char *name,
+ gpointer data)
+{
+ GskRenderNode *node, *repeat_node;
+ graphene_rect_t *bounds = data;
+
+ node = gtk_snapshot_collect_default (nodes, n_nodes, name, NULL);
+ if (node == NULL)
+ return NULL;
+
+ repeat_node = gsk_repeat_node_new (&bounds[0],
+ node,
+ bounds[1].size.width > 0 ? &bounds[1] : NULL);
+ gsk_render_node_set_name (repeat_node, name);
+
+ gsk_render_node_unref (node);
+ g_free (data);
+
+ return repeat_node;
+}
+
+void
+gtk_snapshot_push_repeat (GtkSnapshot *snapshot,
+ const graphene_rect_t *bounds,
+ const graphene_rect_t *child_bounds,
+ const char *name,
+ ...)
+{
+ cairo_region_t *clip;
+ graphene_rect_t *data;
+ char *str;
+
+ if (name)
+ {
+ va_list args;
+
+ va_start (args, name);
+ str = g_strdup_vprintf (name, args);
+ va_end (args);
+ }
+ else
+ str = NULL;
+
+ data = g_new0 (graphene_rect_t, 2);
+ graphene_rect_offset_r (bounds, snapshot->state->translate_x, snapshot->state->translate_y, &data[0]);
+ if (child_bounds)
+ {
+ cairo_rectangle_int_t rect;
+ graphene_rect_offset_r (child_bounds, snapshot->state->translate_x, snapshot->state->translate_y, &data[1]);
+ rectangle_init_from_graphene (&rect, &data[1]);
+ clip = cairo_region_create_rectangle (&rect);
+ }
+ else
+ clip = NULL;
+
+ snapshot->state = gtk_snapshot_state_new (snapshot->state,
+ str,
+ clip,
+ snapshot->state->translate_x,
+ snapshot->state->translate_y,
+ gtk_snapshot_collect_repeat,
+ data);
+
+ if (clip)
+ cairo_region_destroy (clip);
+}
+
static GskRenderNode *
gtk_snapshot_collect_clip (GskRenderNode **nodes,
guint n_nodes,
const char *name,
...) G_GNUC_PRINTF (4, 5);
GDK_AVAILABLE_IN_3_90
+void gtk_snapshot_push_repeat (GtkSnapshot *snapshot,
+ const graphene_rect_t *bounds,
+ const graphene_rect_t *child_bounds,
+ const char *name,
+ ...) G_GNUC_PRINTF (4, 5);
+GDK_AVAILABLE_IN_3_90
void gtk_snapshot_push_clip (GtkSnapshot *snapshot,
const graphene_rect_t *bounds,
const char *name,
append_node (nodemodel, gsk_color_matrix_node_get_child (node), priv->nodes->len - 1);
break;
+ case GSK_REPEAT_NODE:
+ append_node (nodemodel, gsk_repeat_node_get_child (node), priv->nodes->len - 1);
+ break;
+
case GSK_CLIP_NODE:
append_node (nodemodel, gsk_clip_node_get_child (node), priv->nodes->len - 1);
break;
return "Opacity";
case GSK_COLOR_MATRIX_NODE:
return "Color Matrix";
+ case GSK_REPEAT_NODE:
+ return "Repeat";
case GSK_CLIP_NODE:
return "Clip";
case GSK_ROUNDED_CLIP_NODE:
projects / gtk4.git / commitdiff